home *** CD-ROM | disk | FTP | other *** search
/ START Magazine / START VOL 4 NO 1.st / POGOSRC.ARC / EXPRESS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-11-20  |  6.1 KB  |  434 lines
  1.  
  2. /* express.c - Parse out numerical expressions.  String stuff in stringy.c */
  3.  
  4. #include "stdio.h"
  5. #include "pogo.h"
  6.  
  7. get_iexpress()
  8. {
  9. int ok;
  10.  
  11. ok = get_expression();
  12. if (ok == STRING)
  13.     {
  14.     say_fatal("Expecting number got string");
  15.     }
  16. }
  17.  
  18. get_expression()
  19. {
  20. int ftype;
  21. struct func_frame *fuf;
  22. int ok;
  23.  
  24. ok = get_sexpress();
  25. if (ok == UNKNOWN)
  26.     {
  27.     return(get_num_express());
  28.     }
  29. else
  30.     return(ok);
  31. }
  32.  
  33.  
  34. /* get a numerical expression */
  35. get_num_express()
  36. {
  37. return(get_logor());
  38. }
  39.  
  40. need_2num(who,t1,t2)
  41. char *who;
  42. int t1,t2;
  43. {
  44. if (got_stop)
  45.     return(0);
  46. if (t1 != INT || t2 != INT)
  47.     {
  48.     expect_2num("||",t1,t2);
  49.     return(0);
  50.     }
  51. return(1);
  52. }
  53.  
  54. /* Are we part of a logical or expression? */
  55. get_logor()
  56. {
  57. int t1,t2;
  58.  
  59. t1 = get_logand();
  60. if (got_stop)
  61.     return(BAD);
  62. for (;;)
  63.     {
  64.     if (next_token())
  65.         {
  66.         if (cttype == TOK_LOR)
  67.             {
  68.             t2 = get_logor();
  69.             if (!need_2num("||",t1,t2))
  70.                 return(BAD);
  71.             code_op2(OP_LOR);
  72.             return(INT);
  73.             }
  74.         else
  75.             {
  76.             pushback_token();
  77.             return(t1);
  78.             }
  79.         }
  80.     else
  81.         return(t1);
  82.     }
  83. }
  84.  
  85. /* Maybe we're in a logical and? */
  86. get_logand()
  87. {
  88. int t1, t2;
  89.  
  90. t1 = get_lognot();
  91. if (got_stop)
  92.     return;
  93. for (;;)
  94.     {
  95.     if (next_token())
  96.         {
  97.         if (cttype == TOK_LAND)
  98.             {
  99.             t2 = get_logand();
  100.             if (!need_2num("&&",t1,t2))
  101.                 return(BAD);
  102.             code_op2(OP_LAND);
  103.             }
  104.         else
  105.             {
  106.             pushback_token();
  107.             return(t1);
  108.             }
  109.         }
  110.     else
  111.         return(t1);
  112.     }
  113. }
  114.  
  115. /* Logical not - all alone on it's priority level */
  116. get_lognot()
  117. {
  118. int t;
  119.  
  120. if (need_token())
  121.     {
  122.     if (cttype == '!')
  123.         {
  124.         if ((t = get_lognot()) == INT)
  125.             {
  126.             code_op1(OP_LNOT);
  127.             return(INT);
  128.             }
  129.         else
  130.             {
  131.             want_int(t);
  132.             return(BAD);
  133.             }
  134.         }
  135.     else
  136.         {
  137.         pushback_token();
  138.         return(get_compare());
  139.         }
  140.     }
  141. }
  142.  
  143. /* All comparisons are same priority.  Don't allow them to chain.  Ie
  144.    no  (a == b == c) expressions (legal but useless in C) */
  145. get_compare()
  146. {
  147. int t1,t2;
  148. char *ts;
  149. int op;
  150.  
  151. t1 = get_adder();
  152. if (got_stop)
  153.     return(BAD);
  154. if (next_token())
  155.     {
  156.     if (cttype == TOK_EQ || cttype == '=')
  157.         {
  158.         ts = "==";
  159.         op = OP_EQ;
  160.         }
  161.     else if (cttype == TOK_NE)
  162.         {
  163.         ts = "!=";
  164.         op = OP_NE;
  165.         }
  166.     else if (cttype == TOK_LE)
  167.         {
  168.         ts = "<=";
  169.         op = OP_LE;
  170.         }
  171.     else if (cttype == TOK_GE)
  172.         {
  173.         ts = ">=";
  174.         op = OP_GE;
  175.         }
  176.     else if (cttype == '<')
  177.         {
  178.         ts = "<";
  179.         op = OP_LT;
  180.         }
  181.     else if (cttype == '>' )
  182.         {
  183.         ts = ">";
  184.         op = OP_GT;
  185.         }
  186.     else
  187.         {
  188.         pushback_token();
  189.         return(t1);
  190.         }
  191.     t2 = get_adder();
  192.     if (!need_2num(ts,t1,t2))
  193.         return(BAD);
  194.     code_op2(op);
  195.     }
  196. return(t1);
  197. }
  198.  
  199.  
  200.  
  201. /* get adder - next priority binary operations - addition and subtraction,
  202.     and their binary logic equivalents - or, xor. 
  203.    Left to right associativity */
  204. get_adder()
  205. {
  206. int t1,t2;
  207. char *ts;
  208. int op;
  209.  
  210.  
  211. t1 = get_factor();
  212. if (got_stop)
  213.     return;
  214. for (;;)
  215.     {
  216.     if (next_token())
  217.         {
  218.         if (cttype == '+')
  219.             {
  220.             op = OP_ADD;
  221.             ts = "+";
  222.             }
  223.         else if (cttype == '-')
  224.             {
  225.             op = OP_SUB;
  226.             ts = "-";
  227.             }
  228.         else if (cttype == '|')
  229.             {
  230.             op = OP_BOR;
  231.             ts = "|";
  232.             }
  233.         else if (cttype == '^')
  234.             {
  235.             op = OP_BXOR;
  236.             ts = "^";
  237.             }
  238.         else
  239.             {
  240.             pushback_token();
  241.             break;
  242.             }
  243.         t2 = get_factor();
  244.         if (!need_2num(ts,t1,t2))
  245.             return(BAD);
  246.         code_op2(op);
  247.         }
  248.     else
  249.         break;
  250.     }
  251. return(t1);
  252. }
  253.  
  254. /* get factor - highest priority binary operations - multiplication,
  255.    division modulus shifts bitwise ands - left to right associativity */
  256. get_factor()
  257. {
  258. int t1,t2;
  259. char *ts;
  260. int op;
  261.  
  262. t1 = get_signed_prim();
  263. if (got_stop)
  264.     return;
  265. for (;;)
  266.     {
  267.     if (next_token())
  268.         {
  269.         if (cttype == '*')
  270.             {
  271.             op = OP_MUL;
  272.             ts = "*";
  273.             }
  274.         else if (cttype == '/')
  275.             {
  276.             op = OP_DIV;
  277.             ts = "/";
  278.             }
  279.         else if (cttype == '%')
  280.             {
  281.             op = OP_MOD;
  282.             ts = "%";
  283.             }
  284.         else if (cttype == '&')
  285.             {
  286.             op = OP_BAND;
  287.             ts = "&";
  288.             }
  289.         else if (cttype == TOK_LSHIFT)
  290.             {
  291.             op = OP_LSHIFT;
  292.             ts = "<<";
  293.             }
  294.         else if (cttype == TOK_RSHIFT)
  295.             {
  296.             op = OP_RSHIFT;
  297.             ts = ">>";
  298.             }
  299.         else
  300.             {
  301.             pushback_token();
  302.             break;
  303.             }
  304.         t2 = get_signed_prim();
  305.         if (!need_2num(ts,t1,t2))
  306.             return(BAD);
  307.         code_op2(op);
  308.         }
  309.     else
  310.         break;
  311.     }
  312. return(t1);
  313. }
  314.  
  315. /* get signed primitive - a primitive with unary plus or minus or
  316.    bitwise not */
  317. get_signed_prim()
  318. {
  319. int t;
  320.  
  321. if (!need_token())
  322.     return;
  323. if (cttype == '-')
  324.     {
  325.     if ((t = get_signed_prim()) == INT)
  326.         code_op1(OP_NEG);
  327.     else
  328.         want_int(t);
  329.     }
  330. else if (cttype == '+')
  331.     {
  332.     if ((t = get_signed_prim()) != INT)
  333.         want_int(t);
  334.     }
  335. else if (cttype == '~')
  336.     {
  337.     if ((t = get_signed_prim()) == INT)
  338.         code_op1(OP_BNOT);
  339.     }
  340. else
  341.     {
  342.     pushback_token();
  343.     return(get_prim());
  344.     }
  345. return(INT);
  346. }
  347.  
  348. push_var()
  349. {
  350. Symbol *avar;
  351.  
  352. avar = csym;
  353. if (next_token())
  354.     array_ix(avar);
  355. if (!got_stop)
  356.     code_arr_var(avar);
  357. if (avar->scope == LOCAL && !in_creature && avar->assigned == 0)
  358.     {
  359.     used_not_assigned(avar->name);
  360.     }
  361. avar->used = 1;
  362. }
  363.  
  364. /* get primitive - a number, variable, or expression in parenthesis */
  365. get_prim()
  366. {
  367. Symbol *avar;
  368. int t;
  369.  
  370. if (!need_token())
  371.     return(BAD);
  372. if (ctoke[0] == TOK_LPAREN)
  373.     {
  374.     t = get_expression();
  375.     if (got_stop)
  376.         return(BAD);
  377.     if (!next_token() || ctoke[0] != TOK_RPAREN)
  378.         {
  379.         say_fatal("Missing right parenthesis");
  380.         return(BAD);
  381.         }
  382.     return(t);
  383.     }
  384. if (cttype == TOK_NUM)
  385.     {
  386.     code_num(OP_CON, (NUMBER)cint );
  387.     }
  388. else if (cttype == TOK_VAR)
  389.     {
  390.     if (csym->type == INT)
  391.         {
  392.         push_var();
  393.         }
  394.     else if (csym->type == CONSTANT)
  395.         {
  396.         code_num(OP_CON, (NUMBER)csym->symval.i);
  397.         }
  398.     else if (csym->type == FUNC || csym->type == FFUNC || csym->type == PREDEF)
  399.         call_func(csym, 1, INT);
  400.     else
  401.         {
  402.         want_prim();
  403.         return(BAD);
  404.         }
  405.     }
  406. else if (cttype == TOK_CLOSESTT)
  407.     get_closestt();
  408. else if (cttype == TOK_CREAD)
  409.     get_cread();
  410. else if (cttype == TOK_SPAWN)
  411.     get_spawn();
  412. else if (constant_secret(ctoke))
  413.     ;
  414. else if (cttype == TOK_UNDEF)
  415.     {
  416.     char buf[80];
  417.  
  418.     strcpy(buf, ctoke);
  419.     if (!precall_func(1,INT))
  420.         {
  421.         undefined(buf);
  422.         return(BAD);
  423.         }
  424.     }
  425. else
  426.     {
  427.     want_prim();
  428.     return(BAD);
  429.     }
  430. return(INT);
  431. }
  432.  
  433.  
  434.